广度优先搜索（迷宫问题2）

迷宫问题求最短路径

---

在结构体中多加入一个road记录该结构体的来源，然后存入数组，再将数组反向输出即可。

/*
S01E
0010
0010
0100
0000

S010
0000
0010
01E0
0000

S011
0011
1111
1111
111E
*/
#include<stdio.h>
#include<string.h>
typedef struct node
{
    int x;
    int y;
    int step;
    int road;
}Node;
int main()
{
    int stratx,straty,i,j,i1,j1,m=5,n=4,head=0,tail=0;
    //scanf("%d %d",&m,&n);
    char map[m][n];
    int flag[m][n],next[4][2]={0,1,1,0,0,-1,-1,0};
    Node s[m*n],turn[m*n];
    memset(map,0,sizeof(map));
    memset(flag,0,sizeof(flag));
    memset(s,0,sizeof(s));
    for (i=0;i<m;i++)
    gets(map[i]);
    //查找起点 
    for (i=0;i<m;i++)
    {
        for (j=0;j<n;j++)
        {
            if (map[i][j]=='S')
            {
                flag[i][j]=1;
                //记录起点
                stratx=i;
                straty=j; 
                //步数为0 
                s[tail].step=0;
                //改点为起点，所以前一个点设为0 
                s[tail].road=0;
                tail++;
            }
        }
    }
    //不断循环 
    while (head<tail)
    {
        for (i=0;i<4;i++)
        {
            //记录下一个点的坐标 
            i1=s[head].x+next[i][0];
            j1=s[head].y+next[i][1];
            //判断越界 
            if (i1<0||i1>=m||j1<0||j1>=n)
            continue;
            //入队
            if (flag[i1][j1]==0&&(map[i1][j1]=='0'||map[i1][j1]=='E'))
            {
                flag[i1][j1]=1;
                s[tail].x=i1;
                s[tail].y=j1;
                //步数加一 
                s[tail].step=s[head].step+1;
                //由于一个点可以产生多个点，所以我们选择用产生的点来记录前一个点 
                //此时s[tail]是由s[head]产生的，所以将head存入s[tail].road中 
                s[tail].road=head;
                tail++;
            }
            //判断终点
            if (map[i1][j1]=='E')
            {
                //由于后面head没用了，所以用head记录走的步数 
                head=s[tail-1].step;
                tail--;
                //存入数组turn 
                for (i=0;tail!=0;i++)//起点的tail==0 
                {
                    //printf("%d %d\n",s[tail].x,s[tail].y);
                    turn[i].x=s[tail].x;
                    turn[i].y=s[tail].y;
                    tail=s[tail].road;
                }
                printf("%d %d\n",stratx,straty);
                //反向输出 
                for (i--;i>=0;i--)
                printf("%d %d\n",turn[i].x,turn[i].y);
                printf("该地图至少走%d步可以到达终点",head);
                return 0;
            }
        }
        //每算完一个点的四个方向就将这个点出队 
        head++;
    }
    //若上面找不到，则无解 
    printf("Are you kidding me?\n这个地图有解？"); 
}